// src/utils/common.js

import { ElMessage } from "element-plus";
import { useDataStore } from "@/store/index.js"; // 引入 Pinia Store
import { getDictData } from "@/api/common.js";

let _debounceTimeout = null;
let _throttleRunning = false;
/**
 * 防抖
 * @param {Function} 执行函数
 * @param {Number} delay 延时ms
 */
export const debounce = (fn, delay = 500) => {
  clearTimeout(_debounceTimeout);
  _debounceTimeout = setTimeout(() => {
    fn();
  }, delay);
};
/**
 * 节流
 * @param {Function} 执行函数
 * @param {Number} delay 延时ms
 */
export const throttle = (fn, delay = 500) => {
  if (_throttleRunning) {
    return;
  }
  _throttleRunning = true;
  fn();
  setTimeout(() => {
    _throttleRunning = false;
  }, delay);
};

/**
 * 本地存储操作
 */
const Storage = {
  /**
   * 设置本地存储
   * @param {string} key - 键名
   * @param {any} value - 键值
   */
  setItem(key, value) {
    try {
      const serializedValue = typeof value === "object" ? JSON.stringify(value) : value;
      localStorage.setItem(key, serializedValue);
    } catch (error) {
      console.error("Error setting item to localStorage", error);
    }
  },

  /**
   * 获取本地存储
   * @param {string} key - 键名
   * @returns {any} - 键值
   */
  getItem(key) {
    try {
      const value = localStorage.getItem(key);
      try {
        return JSON.parse(value);
      } catch {
        return value;
      }
    } catch (error) {
      console.error("Error getting item from localStorage", error);
      return null;
    }
  },

  /**
   * 删除本地存储
   * @param {string} key - 键名
   */
  removeItem(key) {
    try {
      localStorage.removeItem(key);
    } catch (error) {
      console.error("Error removing item from localStorage", error);
    }
  },

  /**
   * 清空所有本地存储
   */
  clear() {
    try {
      localStorage.clear();
    } catch (error) {
      console.error("Error clearing localStorage", error);
    }
  },
};

/**
 * Token 管理
 */
const TOKEN_KEY = "token"; // 您可以根据需要自定义键名

const Token = {
  /**
   * 保存 Token 到本地存储
   * @param {string} token - Token 值
   */
  saveToken(token) {
    Storage.setItem(TOKEN_KEY, token);
  },

  /**
   * 从本地存储获取 Token
   * @returns {string|null} - Token 值
   */
  getToken() {
    return Storage.getItem(TOKEN_KEY);
  },

  /**
   * 删除本地存储中的 Token
   */
  removeToken() {
    Storage.removeItem(TOKEN_KEY);
  },

  /**
   * 检查 Token 是否存在
   * @returns {boolean} - Token 是否存在
   */
  hasToken() {
    return !!Storage.getItem(TOKEN_KEY);
  },
};

/**
 * 复制文本到剪贴板
 * @param {string} text - 要复制的文本
 * @returns {Promise<void>}
 */
export async function copyText(text) {
  try {
    await navigator.clipboard.writeText(text);
    showMessage("文本已复制到剪贴板！", "success");
  } catch (error) {
    console.error("复制失败", error);
    showMessage("复制失败，请手动复制。", "error");
  }
}

/**
 * 封装 Element Plus 的 ElMessage
 * @param {string} message - 消息内容
 * @param {string} type - 消息类型（'success', 'error', 'warning', 'info'）
 */
export function showMessage(message, type) {
  ElMessage({
    message,
    type,
    duration: 3000, // 持续时间（毫秒）
    showClose: true, // 是否显示关闭按钮
    offset: 60, // 距离顶部的距离（像素）
  });
}

/**
 * 获取当前时间戳
 * @returns {number} - 当前时间戳
 */
export function formatDate(row, column, cellValue) {
  if (!cellValue) return ""; // 检查值是否存在
  return cellValue.split(" ")[0]; // 只保留年月日部分
}

export function formatSetDate(cellValue) {
  if (!cellValue) return ""; // 检查值是否存在
  return cellValue.split(" ")[0]; // 只保留年月日部分
}
// 在获取组件时间后进行格式化
export function formatDateEl(date) {
  if (!date) {
    return [];
  }
  const options = { year: "numeric", month: "2-digit", day: "2-digit" };
  const formattedDate = new Intl.DateTimeFormat("zh-CN", options).format(new Date(date));
  return formattedDate.replace(/\//g, "-"); // 替换斜杠为横杠
}
// 在获取组件时间后进行格式化-datatime
export function formatDateTime(date) {
  if (!date) {
    return [];
  }
  const options = {
    year: "numeric",
    month: "2-digit",
    day: "2-digit",
    hour: "2-digit",
    minute: "2-digit",
    second: "2-digit",
    hour12: false, // 使用24小时制
  };
  const formattedDate = new Intl.DateTimeFormat("zh-CN", options).format(new Date(date));
  return formattedDate.replace(/\//g, "-"); // 替换斜杠为横杠
}
//处理组件的时间格式
export const formatTime = (date) => {
  if (!date) {
    return [];
  }
  const hours = String(date.getHours()).padStart(2, "0"); // 获取小时并补零
  const minutes = String(date.getMinutes()).padStart(2, "0"); // 获取分钟并补零
  return `${hours}:${minutes}`; // 返回格式化的时间字符串
};
// 函数：根据 dictValue 返回相应的 dictLable
export function getDictValue(list, dictValue) {
  if (!list) {
    return "";
  }
  if (!list.length) {
    return "";
  }
  if (!dictValue) {
    return "";
  }
  const item = list.find((i) => i.dictValue === dictValue);

  return item ? item.dictLabel : "";
}
export function getDictCheckboxLabels(list, dictValues) {
  if (!Array.isArray(list)) {
    console.error("传入的列表不是数组:", list);
    return "";
  }
  if (!list.length) {
    return "";
  }
  if (!dictValues) {
    return "";
  }

  // 将传入的逗号分隔字符串转换为数组
  const values = dictValues.split(",");

  // 遍历数组，获取每个值对应的 dictLabel
  const labels = values.map((value) => {
    const item = list.find((i) => i.dictValue === value.trim());
    return item ? item.dictLabel : "";
  });

  // 过滤掉无效的值，并合并为逗号分隔的字符串
  return labels.filter((label) => label).join(",");
}

// 函数：根据 dictLabel 返回相应的 dictValue
export function getDictValuet(list, type) {
  if (!Array.isArray(list)) {
    console.error("传入的列表不是数组:", list);
    return "";
  }
  const item = list.find((i) => i.dictType === type);
  return item ? item.dictValue : "";
}

//将数据处理成element-plus的回显数据格式
export function formatDateRange(startTime, endTime) {
  const startDate = new Date(startTime);
  const endDate = new Date(endTime);

  const format = (date) => {
    if (!date) {
      return [];
    }
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, "0"); // 月份从0开始，需要+1
    const day = String(date.getDate()).padStart(2, "0");
    return `${year}-${month}-${day}`; // 返回 YYYY-MM-DD 格式
  };

  return [format(startDate), format(endDate)]; // 返回日期范围数组
}
export function formatTimeRange(startTime, endTime) {
  if (!startTime || !endTime) {
    return [];
  }
  // 将时间字符串转换为 Date 对象
  const startDate = new Date(startTime);
  const endDate = new Date(endTime);
  // 返回包含开始和结束时间的 Date 对象数组
  return [startDate, endDate];
}

export { Storage, Token };
/**
 * 判断权限是否有指定ID
 * @param {Array} roleMenuList - 角色菜单列表（ID数组）
 * @param {string} permissionId - 权限ID
 * @returns {boolean} - 是否拥有权限
 */
export function checkPermission(roleMenuList, permissionId) {
  return roleMenuList.includes(permissionId);
}

// 验证是否为blob格式
export function blobValidate(data) {
  return data.type !== "application/json";
}
/**
 * 参数处理
 * @param {*} params  参数
 */
export function tansParams(params) {
  let result = "";
  for (const propName of Object.keys(params)) {
    const value = params[propName];
    var part = encodeURIComponent(propName) + "=";
    if (value !== null && value !== "" && typeof value !== "undefined") {
      if (typeof value === "object") {
        for (const key of Object.keys(value)) {
          if (value[key] !== null && value[key] !== "" && typeof value[key] !== "undefined") {
            let params = propName + "[" + key + "]";
            var subPart = encodeURIComponent(params) + "=";
            result += subPart + encodeURIComponent(value[key]) + "&";
          }
        }
      } else {
        result += part + encodeURIComponent(value) + "&";
      }
    }
  }
  return result;
}

//获取字典列表
export async function getDictList(item) {
  let list = [];
  await getDictData().then((res) => {
    if (res.code == "200") {
      for (let i = 0; i < res.data.length; i++) {
        if (res.data[i].dictType == item) {
          list.push({
            label: res.data[i].dictLabel,
            value: res.data[i].dictValue,
          });
        }
      }
    }
  });
  return list;
}

//新获取字典数据
export const getdict = async (item) => {
  await getDictData().then((res) => {
    if (res.code == "200") {
      for (let i = 0; i < res.data.length; i++) {
        if (res.data[i].dictValue == item) {
          return res.data[i].dictLabel;
        }
      }
    }
  });
};
//获取字典数据
export const getDict = (type, item) => {
  const dataStore = useDataStore();
  const projectStatus = computed(() => dataStore[type]);
  return projectStatus.value?.find((entry) => entry.dictValue === item)?.dictLabel ?? "出错";
};
//模糊查询字典数据

//当前时间
export const nowTime = () => {
  const now = new Date();
  const year = now.getFullYear();
  const month = String(now.getMonth() + 1).padStart(2, "0"); // Months are zero-based
  const day = String(now.getDate()).padStart(2, "0");
  const hours = String(now.getHours()).padStart(2, "0");
  const minutes = String(now.getMinutes()).padStart(2, "0");
  const seconds = String(now.getSeconds()).padStart(2, "0");

  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
};
